home *** CD-ROM | disk | FTP | other *** search
/ Practical Algorithms for Image Analysis / Practical Algorithms for Image Analysis.iso / LIBIP / PCC2.H < prev    next >
Encoding:
C/C++ Source or Header  |  1999-09-11  |  14.7 KB  |  403 lines
  1. /* 
  2.  * pcc2.h
  3.  * 
  4.  * Practical Algorithms for Image Analysis
  5.  * 
  6.  * Copyright (c) 1997, 1998, 1999 MLMSoftwareGroup, LLC
  7.  */
  8.  
  9. /* PCC2.H:      header file includes former pcc.h and pccStruct.h
  10.  *
  11.  */
  12.  
  13.  
  14. #ifndef _PCC2_H_
  15. #define    _PCC2_H_
  16.  
  17. /* PCC.H:       include file for PCC programs  */
  18.  
  19. /* no. of 0, 1, 2, and 3 direction chain codes, and features */
  20. #define NCODE0 1
  21. #define NCODE1 8
  22. #define NCODE2 64
  23. #define NCODE3 512
  24. #define NCODEF 9
  25.  
  26. #define CODE0 193               /* code for 0 segment code */
  27. #define MINCODE1 194            /* min/max code values for   */
  28. #define MAXCODE1 201            /*   1, 2, and 3 segment codes */
  29. #define MINCODE2 202
  30. #define MAXCODE2 241
  31. #define MINCODE3 1
  32. #define MAXCODE3 192
  33. #define MINFEATCODE 242         /* min code value for features 
  34.                                  * * * endpt, bifirc, cross */
  35.  
  36. /* branches */
  37. #define NDIRNSPERFEATURE 3      /* no. directions per feature */
  38. #define MAXBRANCH 300           /* max no. of branches on one chain */
  39.  
  40. /* feature codes */
  41. #define STOPCODE 255            /* code after last codeword in storage */
  42. #define ENDCODE 242             /* feature codes */
  43. #define LINECODE 243
  44. #define BIFCODE 244
  45. #define CROSSCODE 245
  46. #define STARTCODE 246           /* start code of structure */
  47. #define LINEBRCODE 247          /* break feature codes */
  48. #define BIFBRCODE 248
  49. #define CROSSBRCODE 249
  50.  
  51. /* location in feature code array */
  52. #define NSTOPCODE 0
  53. #define NENDCODE 1
  54. #define NLINECODE 2
  55. #define NBIFCODE 3
  56. #define NCROSSCODE 4
  57. #define NSTARTCODE 5
  58. #define NLINEBRCODE 6
  59. #define NBIFBRCODE 7
  60. #define NCROSSBRCODE 8
  61.  
  62. /* maximum number of code words */
  63. #define NDECODE 255
  64.  
  65. /* for coding, feature junction points are set to not IMGOFF or IMGON */
  66. #define ERASED 1                /* feature node erased when coding image */
  67.  
  68. /* maximum no. of level-1 lines per loop */
  69. #define MAXPERLOOP 300
  70.  
  71. /* code for line type in level 1 attributes -- gives endpt. types */
  72. #define EELINE 1                /* EE = End, End */
  73. #define EBLINE 2                /* EB = End, Branch */
  74. #define ECLINE 3                /* EC = End, Cross */
  75. #define BELINE 4                /* BE = Branch, End */
  76. #define BBLINE 5
  77. #define BCLINE 6
  78. #define CELINE 7                /* CE = Cross, End */
  79. #define CBLINE 8
  80. #define CCLINE 9
  81. #define RLELINE 10              /* RLE = bReak, Line, End */
  82. #define RLBLINE 11
  83. #define RLCLINE 12
  84. #define RBELINE 13
  85. #define RBBLINE 14
  86. #define RBCLINE 15
  87. #define RCELINE 16
  88. #define RCBLINE 17
  89. #define RCCLINE 18
  90.  
  91.  
  92.  
  93.  
  94. /* PCCSTRUCT.H  contains structures for TLC programs
  95.  *
  96.  */
  97.  
  98. #include <images.h>             /* image format information file */
  99.  
  100. /* structure contains PCC codes */
  101. struct code {
  102.   unsigned char code0[NCODE0],  /* 0-vector chains */
  103.     code1[NCODE1],              /* 1-vector chains */
  104.     code2[NCODE2],              /* 2-vector chains */
  105.     code3[NCODE3],              /* 3-vector chains */
  106.     codeFeat[NCODEF];           /* feature codes */
  107. };
  108.  
  109. /* enough different branch structures to build a tree */
  110. /* stack of branches waiting to be coded */
  111.  
  112. struct branch1 {                /* location of branches yet to code */
  113.   long x, y;                    /* location of branch */
  114.   long variable;                /* used for dirn or type in diff fcts */
  115.   struct branch1 *next, *previous;  /* pointers to next/last branches */
  116. };
  117.  
  118. /* line tolerances for line processing */
  119. struct tolerances {
  120.   long minEE,                   /* minimum endpt. to endpt. line length */
  121.     minFE;                      /* end to/from feature minimum length */
  122. };
  123.  
  124. /* variables to calculate level 1 attributes */
  125. struct attrVar {
  126.   long iByteCode,               /* byte location beginning line in code */
  127.     iByteWidth,                 /* byte location beginning line in widths */
  128.     inOut,                      /* see note above */
  129.     feat1,                      /* start and end features of line */
  130.     feat2, code1,               /* beginning and ending PCC of line */
  131.     code2, width,               /* sum of line widths */
  132.     nWidth,                     /* number of line widths */
  133.     length,                     /* length [10 * pixel spacing] of line */
  134.     nPts;                       /* no. points in line */
  135.   struct point sumPt;           /* sums of x,y values */
  136.   struct point pt1, pt2;        /* start and end image coordinates of line */
  137.   struct rectangle box;         /* bounding box of line */
  138. } *attrVar;                     /* input variables to calc. attr.s */
  139.  
  140. /* level 1 attributes */
  141. struct attributes {
  142.   long type,                    /* feature type */
  143.     iByteCode,                  /* byte offset in fcCode beginning line */
  144.     iByteWidth,                 /* byte offset in width array beginning line */
  145.     inOut,                      /* input and output branches at node */
  146.     width,                      /* average line width or EXO */
  147.     length,                     /* line length in horiz/vert pixel spacing */
  148.     nPts;                       /* number of points along line */
  149.   struct point pt1, pt2;        /* start/end coord.s */
  150.   unsigned char dirn1, dirn2;   /* endpoint directions */
  151.   struct rectangle box;         /* bounding box of line */
  152.   struct point sumPt;           /* sum of x,y points along line */
  153. };
  154.  
  155. /* level 3 structures */
  156. struct structures {             /* level 3 connected line structures */
  157.   long iAttr,                   /* list of <iAttr> of beginning of structs */
  158.     nLines,                     /* no. level 1 lines in structure */
  159.     nEnds,                      /* no. endlines in structure */
  160.     nLoops,                     /* no. loops in structure */
  161.     width,                      /* average width of lines in structure */
  162.     length,                     /* total length of lines in structure */
  163.     maxLength;                  /* max. length of lines in structure */
  164.   double centroidX, centroidY;  /* x,y centroid of all lines in structure */
  165.   struct rectangle box;         /* bounding box of structure */
  166. };
  167.  
  168. /* level 3 nearest neighbor structure */
  169. struct nn {                     /* data structure for each NN */
  170.   long iStrct;                  /* index of structure */
  171.   long dist;                    /* distance */
  172. };
  173. struct strctNN {
  174.   long nNN;                     /* no. nearest nbrs */
  175.   struct nn *nn;                /* list of nearest nbrs */
  176. };
  177.  
  178. /* level 2 loops */
  179. struct loop {                   /* level 2 loops */
  180.   long *iAttr,                  /* <iAttr> list per loop */
  181.     n;                          /* no. level 1 lines per loop */
  182. };
  183.  
  184. /* PCC features */
  185. struct pccfeat {
  186.   long *iAttrEnd,               /* line list number + 1 of end,  */
  187.    *iAttrBif,                   /* bif., cross, loop  */
  188.    *iAttrCross,                 /* +ve if pt1, -ve if pt2 in <attr> */
  189.    *iAttrLoop;
  190.   long nEnd,                    /* no. of endpoints */
  191.     nBif,                       /* no. of bifurations */
  192.     nCross,                     /* no. of crosses */
  193.     nLoop;                      /* no. of junctions within loops */
  194. };
  195.  
  196. /* array of near endpt. pairs */
  197. struct nearEnds {
  198.   struct point ptI,             /* coord.s of 2 endpoints */
  199.     ptJ;
  200. };
  201.  
  202. /* boundary points */
  203. struct bound {
  204.   long *iAttr;                  /* <iAttr> list of boundary pts. */
  205. };
  206.  
  207. /* level 2 endlines */
  208. struct endLine {
  209.   struct point locn1,           /* location of one end of line */
  210.     locn2;                      /* location of end which actually ends */
  211.   int iAttr1,                   /* level 1 index of line */
  212.     iAttr2,                     /* level 1 index of line if 2 break lines make
  213.                                  * * up line; else -1 */
  214.     type;                       /* feature type */
  215.   long length;                  /* line length [x10] */
  216.   unsigned char dirn1,          /* endpoint direction */
  217.     dirn2;                      /* endpoint direction at end which ends */
  218. };
  219.  
  220. /* level 2 bifurcations (3 branches per bifurcation) */
  221. struct bif {
  222.   struct point locn;            /* location of bifurcation junction */
  223.   int iAttr[3],                 /* level 1 index of branch */
  224.     type[3];                    /* feature type */
  225.   long length[3];               /* line length [x10] */
  226.   unsigned char dirn1[3],       /* endpoint direction at bifurc. */
  227.     dirn2[3];                   /* endpoint direction away from bifurc. */
  228. };
  229.  
  230. /* segment structure contains information on endpoints which
  231.  * are located within square, non-overlapped image regions (segments) */
  232. struct segment {
  233.   short **list;                 /* pointer to list of iAttr for endpts */
  234.   long nX, nY,                  /* no. segments per width (x), length (y) */
  235.     size,                       /* sidelength of each segment */
  236.    *nPer;                       /* no. endpt.s per each segment */
  237. };
  238.  
  239.  
  240.  
  241. /* WW.H contains structures for line fitting programs
  242.  *
  243.  */
  244.  
  245. #define ABS(A) (((A) >= 0) ? (A): -(A))  /* integer absolute value */
  246. #define ABSF(A) (((A) >= 0.0) ? (A): -(A))  /* floating absolute value */
  247.  
  248. #define DIAG 1.4142135          /* diagonal dist between pixels */
  249.  
  250. /* distances are kept *100 to obtain 2 digit precision for diagonals */
  251. #define HORIZVERT 100           /* unit length of segment times 100 */
  252. #define DIAG100 141             /* unit diagonal distance times 100 */
  253.  
  254. #define MDFLT 5                 /* max length of corner curvature */
  255.  
  256. #define L_DFLT 13               /* min arc-length between features */
  257. #define L_MIN 5                 /* min user-choice of arc-length parameter */
  258. #define M_MAX 3                 /* max arc-length of corner */
  259.  
  260. #define MAXPERCODE 6            /* 3 coords per PCC * 2 no.s per coord */
  261. #define MAXBRPERNODE 4          /* maximum branches from a node */
  262.  
  263. /* node types */
  264. /*
  265.  * #define ENDCOORD -1
  266.  * #define BIFCOORD -2
  267.  * #define CROSSCOORD -3
  268.  * #define STARTCOORD -4
  269.  * #define LINEBRCOORD -5
  270.  * #define BIFBRCOORD -6
  271.  * #define CROSSBRCOORD -7
  272.  */
  273.  
  274. #define MAXADJEDGES 3           /* max adjacent edges to another edge */
  275.  
  276. /* wing-walk feature types */
  277. #define WWSTRT 1
  278. #define WWCORNER 2
  279. #define WWCURVE  3
  280. #define WWEND 0
  281.  
  282. #define EPSILON1 0.0            /* tolerance on min peak width */
  283. #define EPSILON2 0.0            /* tolerance on corner/curve arc length */
  284.  
  285. #define BORDERTHETA 50.0        /* flag (anything > PI) indicates that theta
  286.                                  * * * has not been calculated because border /*
  287.                                  * * * 
  288.                                  * * * /* curve sweep -- indicates if the curve arc sweeps <180, >180, =180,
  289.                                  * * * or an entire 360 degrees, ie a circle */
  290. #define CURVELT180 0
  291. #define CURVEGT180 1
  292. #define CURVEEQ180 2            /* semicircle */
  293. #define CURVEEQ360 3            /* circle */
  294.  
  295. /* Wing-Walk Structures */
  296.  
  297. struct wwPar {
  298.   long m,                       /* middle segment length */
  299.     l,                          /* total wing-walk length */
  300.     w;                          /* 'wing' length */
  301. };
  302.  
  303. /* coords in double floating precision  */
  304. /* already defined in images.h
  305.  * struct dpoint{
  306.  * double x, y;
  307.  * };
  308.  */
  309.  
  310. struct wwfeats {
  311.   struct point strt,            /* starting and ending coord.s of feature */
  312.     end;
  313.   struct dpoint center;         /* center of curvature for curve */
  314.   double radius;                /* radius of curvature (=0 for strt line) */
  315. };
  316.  
  317. struct edge {                   /* data indices between ends or jcts */
  318.   long iLow,                    /* low and high indices in data array */
  319.     iHigh;
  320. };
  321.  
  322. struct theta {                  /* theta plot */
  323.   double theta,                 /* theta curvature value */
  324.     length;                     /* arclength from beginning to current */
  325. };
  326.  
  327.  
  328. /* structures for feature linked list */
  329.  
  330. struct featNode {               /* feature nodes pointing to feature par.s */
  331.   int type;                     /* type of wing-walk feature */
  332.   struct dpoint intrsct;        /* intersection point of tangents to curve */
  333.   char *info;                   /* contains parameter information */
  334.   struct featNode *next,        /* next node */
  335.    *previous;                   /* previous node */
  336. };
  337.  
  338. struct featK {                  /* corner feature parameters */
  339.   struct point coord;           /* coordinate of corner feature */
  340. };
  341.  
  342. struct featC {                  /* curve feature parameters */
  343.   struct point trans1, trans2;  /* beginning and ending transition points */
  344.   struct dpoint center;         /* coord. of center of circle of curvature */
  345.   double radiusC;               /* radius of curvature */
  346.   short dirn;                   /* trans pts. in CCW order (1), or CW (-1) */
  347. };
  348.  
  349. /* structures for graph representation */
  350.  
  351. struct edgeList {               /* list of graph edges */
  352.   struct edge edge;             /* data indices of ends of edge */
  353.   long node1, node2;            /* index of start/end nodes, -1 if no node */
  354.   long adjEdge1[MAXADJEDGES],   /* edge indices of start and end adjacent */
  355.     adjEdge2[MAXADJEDGES],      /*   edges: +ve if entering, -ve if leaving */
  356.     nAdjEdge1, nAdjEdge2;       /* no. of start and end adjacent edges */
  357.   long length;                  /* length * 100 */
  358. };
  359.  
  360. struct nodeList {               /* list of graph nodes */
  361.   long type;                    /* node type */
  362.   struct point locn;            /* x,y location */
  363.   long incEdge[4],              /* edges incident to node */
  364.     nEdges;                     /* no. edges incident to node */
  365.   struct featNode *wwFeatPtr[2];  /* ptr to ww features in linked list */
  366.   long nWWFeatPtr;              /* no. of ww features pointed to */
  367. };
  368.  
  369.  
  370. struct strghtEdges {            /* edge list of adjacent straight edges */
  371.   long front, end;              /* straight edge at front and end of edge */
  372.   int flag;                     /* used for marking edge already counted */
  373. };
  374.  
  375. /* Function Definitions */
  376. int pcccodes ();
  377. int pcccode (unsigned char **, long, long);
  378. int pcctrack (unsigned char **, long *, long *, long *, struct branch1 **, long *);
  379. int pccrstore (long, long, long);
  380. int pcclstore (long *, long);
  381. int pccfstore (long);
  382. int pccwrite (char *, unsigned char *, long, long, long);
  383. int pccbranch (struct branch1 **, long, long, long);
  384. int nbrtoxy (long, long, long, long *, long *);
  385. int pccread (char *, unsigned char **, long *, long *, long *);
  386. int pccdecodes ();
  387. int pccdecode (unsigned char **, long, long, int);
  388. int pccdetrack (unsigned char **, int *, int *, long, long, long, long);
  389. int pcc2xy (struct point *, long *);
  390. int detrack (int *, int *, int, struct point *, long *);
  391. int tlc1attr (struct attributes **, long *);
  392. int tlc1track (long *, long *, struct attrVar *, int);
  393. int tlc1dirn (struct attributes *, long);
  394. long dirncalc (long, long);
  395. int tlc1store (struct attrVar, struct attributes *, long *);
  396. int tlc1tag (struct attributes *, long, long, long);
  397. int looptest (struct attributes *, long, struct branch1 *, long);
  398. int tlc1rid (struct attributes *, long);
  399. int tlc3structs (struct attributes *, long, struct structures **, long *);
  400. int tlc3feats (struct attributes *, long, struct structures *, long);
  401.  
  402. #endif /* _PCC2_H_ */
  403.